//LoginRequest.kt 登录请求模型

// data/models/LoginRequest.kt
package com.example.xxcjgl.data.models

import com.google.gson.annotations.SerializedName

/**
 * 登录请求数据模型
 * 用于向服务器发送登录请求时封装数据
 *
 * @property username 用户名（可以是用户编码或用户名）
 * @property password 登录密码（经过SHA1加密）
 * @property captcha 图形验证码
 */
data class LoginRequest(
    @SerializedName("username")
    val username: String,

    @SerializedName("password")
    val password: String,

    @SerializedName("captcha")
    val captcha: String
) {
    /**
     * 验证登录请求数据的有效性
     */
    fun isValid(): Boolean {
        return username.isNotBlank() &&
                password.isNotBlank() &&
                captcha.isNotBlank() &&
                captcha.length == 4 // 验证码为4位
    }

    /**
     * 获取用于显示的错误信息
     */
    fun getValidationErrors(): String {
        val errors = mutableListOf<String>()

        if (username.isBlank()) {
            errors.add("用户名不能为空")
        }

        if (password.isBlank()) {
            errors.add("密码不能为空")
        }

        if (captcha.isBlank()) {
            errors.add("验证码不能为空")
        } else if (captcha.length != 4) {
            errors.add("验证码必须是4位")
        }

        return errors.joinToString("；")
    }
}

/**
 * 注册请求数据模型（扩展功能，可根据需要添加）
 */
data class RegisterRequest(
    @SerializedName("user_bm")
    val userCode: String,

    @SerializedName("user_xm")
    val userName: String,

    @SerializedName("user_yhcj")
    val userLevel: Int,

    @SerializedName("user_pw")
    val password: String,

    @SerializedName("confirm_password")
    val confirmPassword: String,

    @SerializedName("captcha")
    val captcha: String
) {
    fun isValid(): Boolean {
        return userCode.isNotBlank() &&
                userName.isNotBlank() &&
                password.isNotBlank() &&
                confirmPassword.isNotBlank() &&
                password == confirmPassword &&
                captcha.isNotBlank() &&
                userCode.length == 4 && // 用户编码为4位
                userName.length in 2..10 && // 用户名2-10位
                password.length >= 6 // 密码至少6位
    }

    fun getValidationErrors(): String {
        val errors = mutableListOf<String>()

        if (userCode.isBlank()) {
            errors.add("用户编码不能为空")
        } else if (userCode.length != 4) {
            errors.add("用户编码必须是4位")
        }

        if (userName.isBlank()) {
            errors.add("用户姓名不能为空")
        } else if (userName.length < 2 || userName.length > 10) {
            errors.add("用户姓名必须是2-10位")
        }

        if (password.isBlank()) {
            errors.add("密码不能为空")
        } else if (password.length < 6) {
            errors.add("密码至少需要6位")
        }

        if (confirmPassword.isBlank()) {
            errors.add("确认密码不能为空")
        } else if (password != confirmPassword) {
            errors.add("两次输入的密码不一致")
        }

        if (captcha.isBlank()) {
            errors.add("验证码不能为空")
        }

        return errors.joinToString("；")
    }
}

/**
 * 修改密码请求数据模型
 */
data class ChangePasswordRequest(
    @SerializedName("old_password")
    val oldPassword: String,

    @SerializedName("new_password")
    val newPassword: String,

    @SerializedName("confirm_password")
    val confirmPassword: String
) {
    fun isValid(): Boolean {
        return oldPassword.isNotBlank() &&
                newPassword.isNotBlank() &&
                confirmPassword.isNotBlank() &&
                newPassword == confirmPassword &&
                newPassword.length >= 6 &&
                oldPassword != newPassword
    }

    fun getValidationErrors(): String {
        val errors = mutableListOf<String>()

        if (oldPassword.isBlank()) {
            errors.add("原密码不能为空")
        }

        if (newPassword.isBlank()) {
            errors.add("新密码不能为空")
        } else if (newPassword.length < 6) {
            errors.add("新密码至少需要6位")
        }

        if (confirmPassword.isBlank()) {
            errors.add("确认密码不能为空")
        } else if (newPassword != confirmPassword) {
            errors.add("两次输入的新密码不一致")
        }

        if (oldPassword == newPassword) {
            errors.add("新密码不能与原密码相同")
        }

        return errors.joinToString("；")
    }
}

/**
 * 学生搜索请求模型
 */
data class StudentSearchRequest(
    @SerializedName("keyword")
    val keyword: String,

    @SerializedName("page")
    val page: Int = 1,

    @SerializedName("page_size")
    val pageSize: Int = 20,

    @SerializedName("include_encrypted")
    val includeEncrypted: Boolean = false
) {
    fun isValid(): Boolean {
        return keyword.isNotBlank() && page > 0 && pageSize in 1..100
    }

    fun toQueryMap(): Map<String, String> {
        return mapOf(
            "keyword" to keyword,
            "page" to page.toString(),
            "page_size" to pageSize.toString(),
            "include_encrypted" to includeEncrypted.toString()
        )
    }
}

/**
 * 加密验证请求模型
 */
data class EncryptionVerifyRequest(
    @SerializedName("student_id")
    val studentId: Int,

    @SerializedName("encryption_key")
    val encryptionKey: String
) {
    fun isValid(): Boolean {
        return studentId > 0 && encryptionKey.isNotBlank()
    }
}

/**
 * 批量操作请求模型
 */
data class BatchOperationRequest(
    @SerializedName("operation")
    val operation: String, // "delete", "encrypt", "decrypt"

    @SerializedName("student_ids")
    val studentIds: List<Int>,

    @SerializedName("encryption_key")
    val encryptionKey: String? = null
) {
    fun isValid(): Boolean {
        return operation in listOf("delete", "encrypt", "decrypt") &&
                studentIds.isNotEmpty() &&
                (operation == "delete" || !encryptionKey.isNullOrBlank())
    }
}